home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / tar.gnu / sprite / RCS / tar.c,v < prev    next >
Encoding:
Text File  |  1992-03-29  |  38.8 KB  |  1,760 lines
  1. head     1.5;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.5
  10. date     92.03.28.17.32.54;  author kupfer;  state Exp;
  11. branches ;
  12. next     1.4;
  13.  
  14. 1.4
  15. date     92.03.05.21.38.28;  author rab;  state Exp;
  16. branches ;
  17. next     1.3;
  18.  
  19. 1.3
  20. date     90.10.27.17.51.58;  author rab;  state Exp;
  21. branches ;
  22. next     1.2;
  23.  
  24. 1.2
  25. date     90.06.28.15.35.39;  author rab;  state Exp;
  26. branches ;
  27. next     1.1;
  28.  
  29. 1.1
  30. date     90.03.22.12.53.35;  author rab;  state Exp;
  31. branches ;
  32. next     ;
  33.  
  34.  
  35. desc
  36. @@
  37.  
  38.  
  39. 1.5
  40. log
  41. @Add -L flag (instead of using ALLOW_LONG_NAMES ifdef everywhere).
  42. Lint.  Add gnu_extended_header, with check for Posix archive format.
  43. @
  44. text
  45. @/* Tar -- a tape archiver.
  46.  
  47.     Copyright (C) 1988 Free Software Foundation
  48.  
  49. GNU tar is distributed in the hope that it will be useful, but WITHOUT ANY
  50. WARRANTY.  No author or distributor accepts responsibility to anyone
  51. for the consequences of using it or for whether it serves any
  52. particular purpose or works at all, unless he says so in writing.
  53. Refer to the GNU tar General Public License for full details.
  54.  
  55. Everyone is granted permission to copy, modify and redistribute GNU tar,
  56. but only under the conditions described in the GNU tar General Public
  57. License.  A copy of this license is supposed to have been given to you
  58. along with GNU tar so you can know your rights and responsibilities.  It
  59. should be in a file named COPYING.  Among other things, the copyright
  60. notice and this notice must be preserved on all copies.
  61.  
  62. In other words, go ahead and share GNU tar, but don't try to stop
  63. anyone else from sharing it farther.  Help stamp out software hoarding!
  64. */
  65.  
  66. /*
  67.  * A tar (tape archiver) program.
  68.  *
  69.  * Written by John Gilmore, ihnp4!hoptoad!gnu, starting 25 Aug 85.
  70.  *
  71.  * @@(#)tar.c 1.34 11/6/87 - gnu
  72.  */
  73.  
  74. #include <stdio.h>
  75. #include <assert.h>
  76. #include <sys/types.h>        /* Needed for typedefs in tar.h */
  77. #include <sys/stat.h>        /* JF */
  78. #include <sys/param.h>
  79. #include "getopt.h"
  80.  
  81. #ifdef USG
  82. #define rindex strrchr
  83. #endif
  84.  
  85. #ifdef BSD42
  86. #include <sys/dir.h>
  87. #else
  88. #ifdef MSDOS
  89. #include <sys/dir.h>
  90. #else
  91. #ifdef USG
  92. #ifdef NDIR
  93. #include <ndir.h>
  94. #else
  95. #include <dirent.h>
  96. #endif
  97. #ifndef DIRECT
  98. #define direct dirent
  99. #endif
  100. #define DP_NAMELEN(x) strlen((x)->d_name)
  101. #else
  102. /*
  103.  * FIXME: On other systems there is no standard place for the header file
  104.  * for the portable directory access routines.  Change the #include line
  105.  * below to bring it in from wherever it is.
  106.  */
  107. #include "ndir.h"
  108. #endif
  109. #endif
  110. #endif
  111.  
  112. #ifndef DP_NAMELEN
  113. #define DP_NAMELEN(x)    (x)->d_namlen
  114. #endif
  115.  
  116. extern char     *malloc();
  117. extern char     *getenv();
  118. extern char    *strncpy();
  119. extern char    *index();
  120. extern char    *strcpy();    /* JF */
  121. extern char    *strcat();    /* JF */
  122.  
  123. extern char    *optarg;    /* Pointer to argument */
  124. extern int    optind;        /* Global argv index from getopt */
  125.  
  126. /*
  127.  * The following causes "tar.h" to produce definitions of all the
  128.  * global variables, rather than just "extern" declarations of them.
  129.  */
  130. #define TAR_EXTERN /**/
  131. #include "tar.h"
  132.  
  133. /*
  134.  * We should use a conversion routine that does reasonable error
  135.  * checking -- atoi doesn't.  For now, punt.  FIXME.
  136.  */
  137. #define intconv    atoi
  138. extern int    getoldopt();
  139. extern void    read_and();
  140. extern void    list_archive();
  141. extern void    extract_archive();
  142. extern void    diff_archive();
  143. extern void    create_archive();
  144. extern void    update_archive();
  145. extern void    junk_archive();
  146.  
  147. /* JF */
  148. extern time_t    getdate();
  149. #ifdef __GNU__
  150. extern void *init_buffer();
  151. #else
  152. extern char *init_buffer();
  153. #endif
  154. extern char *get_buffer();
  155. extern void add_buffer();
  156. extern void flush_buffer();
  157.  
  158. time_t new_time;
  159.  
  160. static FILE    *namef;        /* File to read names from */
  161. static char    **n_argv;    /* Argv used by name routines */
  162. static int    n_argc;    /* Argc used by name routines */
  163.                 /* They also use "optind" from getopt(). */
  164.  
  165. void    describe();
  166. void    options();
  167.  
  168. #ifndef S_IFLNK
  169. #define lstat stat
  170. #endif
  171.  
  172. #ifndef DEFBLOCKING
  173. #define DEFBLOCKING 20
  174. #endif
  175.  
  176. #ifndef DEF_AR_FILE
  177. #define DEF_AR_FILE "tar.out"
  178. #endif
  179.  
  180. /* For long options that unconditionally set a single flag, we have getopt
  181.    do it.  For the others, we share the code for the equivalent short
  182.    named option, the name of which is stored in the otherwise-unused `val'
  183.    field of the `struct option'; for long options that have no equivalent
  184.    short option, we use nongraphic characters as pseudo short option
  185.    characters, starting (for no particular reason) with character 10. */
  186.  
  187. struct option long_options[] =
  188. {
  189.     {"create",        0,    0,            'c'},
  190.     {"append",        1,    0,            'r'},
  191.     {"extract",        1,    0,            'x'},
  192.     {"get",            1,    0,            'x'},
  193.     {"list",        1,    0,            't'},
  194.     {"update",        1,    0,            'u'},
  195.     {"catenate",        1,    0,            'A'},
  196.     {"concatenate",        1,    0,            'A'},
  197.     {"read-full-blocks",    0,    &f_reblock,        1},
  198. /*     {"directory",        1,    0,            'C'}, */
  199.     {"newer",        0,    0,            13},    /* JF */
  200.     {"newer-mtime",        1,    0,            'N'},    /* JF */
  201.     {"delete",        1,    0,            'D'},
  202.     {"incremental",        0,    0,            'G'},
  203.     {"starting-file",    1,    0,            'K'},
  204.     {"multi-volume",    0,    &f_multivol,        1},
  205.     {"after-date",        1,    0,            'N'},
  206.     {"to-stdout",        0,    &f_exstdout,        1},
  207.     {"record-number",    0,    &f_sayblock,        1},
  208.     {"files-from",        1,    0,            'T'},
  209.     {"volume",        1,    0,            'V'},
  210.     {"verify",        0,    &f_verify,        1},
  211.     {"exclude",        1,    0,            'X'},
  212.     {"block-size",        1,    0,            'b'},
  213.     {"compare",        0,    0,            'd'},
  214.     {"diff",        0,    0,            'd'},
  215.     {"file",        1,    0,            'f'},
  216.     {"dereference",        0,    &f_follow_links,    1},
  217.     {"ignore-zeros",    0,    &f_ignorez,        1},
  218.     {"keep-old-files",    0,    0,            'k'},
  219.     {"one-file-system",    0,    &f_local_filesys,     1},
  220.     {"modification-time",    0,    &f_modified,        1},
  221.     {"old-archive",        0,    0,            'o'},
  222.     {"old",            0,    0,            'o'},
  223.     {"portability",        0,    0,            'o'},
  224.     {"same-permissions",    0,    &f_use_protection,    1},
  225.     {"preserve-permissions",0,    &f_use_protection,    1},
  226.     {"same-order",        0,    &f_sorted_names,    1},
  227.     {"preserve-order",    0,    &f_sorted_names,    1},
  228.     {"preserve",        0,    0,            10},
  229.     {"verbose",         0,    &f_verbose,        1},
  230.     {"interactive",        0,    &f_confirm,        1},
  231.     {"uncompress",        0,    &f_compress,        1},
  232.     {"compress",        0,    &f_compress,        1},
  233.     {"compress-block",    0,    &f_compress,        2},
  234.     {"info-script",        1,    &f_run_script_at_end,    1},
  235.     {"absolute-paths",    0,    &f_absolute_paths,    1},
  236.     {"version",        0,    0,            11},
  237.     {"help",        0,    0,            12},
  238. #ifdef ALLOW_NO_RECURSE    
  239.     {"no_recurse",          0,      &f_no_recurse,          'n'},
  240. #endif
  241.     {"debug",               0,      &f_debug,               'e'},
  242.     {0, 0, 0, 0}
  243. };
  244.  
  245. /*
  246.  * Main routine for tar.
  247.  */
  248. main(argc, argv)
  249.     int    argc;
  250.     char    **argv;
  251. {
  252.  
  253.         assert(sizeof(union record) == RECORDSIZE);
  254.     tar = argv[0];        /* JF: was "tar" Set program name */
  255.  
  256.     options(argc, argv);
  257.  
  258.     name_init(argc, argv);
  259.     switch(cmd_mode) {
  260.     case CMD_CAT:
  261.     case CMD_UPDATE:
  262.     case CMD_APPEND:
  263.         update_archive();
  264.         break;
  265.     case CMD_DELETE:
  266.         junk_archive();
  267.         break;
  268.     case CMD_CREATE:
  269.         create_archive();
  270.         break;
  271.     case CMD_EXTRACT:
  272.         extr_init();
  273.         read_and(extract_archive);
  274.         break;
  275.     case CMD_LIST:
  276.         read_and(list_archive);
  277.         break;
  278.     case CMD_DIFF:
  279.         diff_init();
  280.         read_and(diff_archive);
  281.         break;
  282.     case CMD_NONE:
  283.         fprintf (stderr,"%s: you must specify exactly one of the r, c, t, x, or d options\n", tar);
  284.         fprintf (stderr,"For more information, type ``%s +help''.\n",tar);
  285.         exit(EX_ARGSBAD);
  286.     }
  287.     if (f_debug) {
  288.         fprintf(stderr, "Tar.gnu: Exiting normally\n");
  289.     }
  290.     exit(0);
  291.     /* NOTREACHED */
  292. }
  293.  
  294.  
  295. /*
  296.  * Parse the options for tar.
  297.  */
  298. void
  299. options(argc, argv)
  300.     int    argc;
  301.     char    **argv;
  302. {
  303.     register int    c;        /* Option letter */
  304.     int        ind = -1;
  305.     extern char version_string[];
  306.  
  307.     /* Set default option values */
  308.     blocking = DEFBLOCKING;        /* From Makefile */
  309.     ar_file = getenv("TAPE");    /* From environment, or */
  310.     if (ar_file == 0)
  311.         ar_file = DEF_AR_FILE;    /* From Makefile */
  312.  
  313.     /* Parse options */
  314.     while ((c = getoldopt(argc, argv,
  315.                   "01234567Ab:BcC:dDef:F:GhikK:lLmMnN:oOpPrRsStT:uvV:wWxX:zZ",
  316.                   long_options, &ind)) != EOF) {
  317.         if (c == 0 && long_options[ind].flag == 0)
  318.             c = long_options[ind].val;
  319.         switch (c) {
  320.         case 0:        /* long options that set a single flag */
  321.             break;
  322.         case 10:    /* preserve */
  323.             f_use_protection = f_sorted_names = 1;
  324.             break;
  325.         case 11:    /* version */
  326.             fprintf(stderr,"%s\n",version_string);
  327.             break;
  328.         case 12:    /* help */
  329.             fprintf(stderr,"This is GNU tar, the tape archiving program.\n");
  330.             describe();
  331.             exit(1);
  332.         case 13:
  333.             f_new_files++;
  334.             goto get_newer;
  335.  
  336.         case '0':
  337.         case '1':
  338.         case '2':
  339.         case '3':
  340.         case '4':
  341.         case '5':
  342.         case '6':
  343.         case '7':
  344.             {
  345.                 /* JF this'll have to be modified for other
  346.                    systems, of course! */
  347. #ifndef LOW_NUM
  348. #define LOW_NUM 0
  349. #define MID_NUM 8
  350. #define HGH_NUM 16
  351. #endif
  352.                 int d,add;
  353.                 static char buf[50];
  354.  
  355.                 d=getoldopt(argc,argv,"lmh", 0, 0);
  356.                 if(d=='l') add=LOW_NUM;
  357.                 else if(d=='m') add=MID_NUM;
  358.                 else if(d=='h') add=HGH_NUM;
  359.                 else goto badopt;
  360.                 sprintf(buf,"/dev/rmt%d",add+c-'0');
  361.                 ar_file=buf;
  362.             }
  363.             break;
  364.  
  365.         case 'A':            /* Arguments are tar files,
  366.                            just cat them onto the end
  367.                            of the archive.  */
  368.             if(cmd_mode!=CMD_NONE)
  369.                 goto badopt;
  370.             cmd_mode=CMD_CAT;
  371.             break;
  372.  
  373.         case 'b':            /* Set blocking factor */
  374.             blocking = intconv(optarg);
  375.             break;
  376.  
  377.         case 'B':            /* Try to reblock input */
  378.             f_reblock++;        /* For reading 4.2BSD pipes */
  379.             break;
  380.  
  381.         case 'c':            /* Create an archive */
  382.             if(cmd_mode!=CMD_NONE)
  383.                 goto badopt;
  384.             cmd_mode=CMD_CREATE;
  385.             break;
  386.  
  387.         case 'C':
  388.             if(chdir(optarg)<0)
  389.                 msg_perror("Can't change directory to %d",optarg);
  390.             break;
  391.  
  392.         case 'd':            /* Find difference tape/disk */
  393.             if(cmd_mode!=CMD_NONE)
  394.                 goto badopt;
  395.             cmd_mode=CMD_DIFF;
  396.             break;
  397.  
  398.         case 'D':            /* Delete in the archive */
  399.             if(cmd_mode!=CMD_NONE)
  400.                 goto badopt;
  401.             cmd_mode=CMD_DELETE;
  402.             /* 
  403.              * XXX Need to fix junk_archive to deal with long 
  404.              * names.  
  405.              */
  406.             fprintf(stderr, "Warning: -D is probably flaky.\n");
  407.             break;
  408.  
  409.         case 'e':
  410.             f_debug = 1;
  411.             break;
  412.  
  413.         case 'f':        /* Use ar_file for the archive */
  414.             ar_file = optarg;
  415.             break;
  416.  
  417.         case 'F':
  418.             /* Since -F is only useful with -M , make it implied */
  419.             f_run_script_at_end++;  /* run this script at the end */
  420.             info_script = optarg;    /* of each tape */
  421.             f_multivol++;
  422.             break;
  423.  
  424.         case 'G':            /* We are making a GNU dump; save
  425.                            directories at the beginning of
  426.                            the archive, and include in each
  427.                            directory its contents */
  428.             if(f_oldarch)
  429.                 goto badopt;
  430.             f_gnudump++;
  431.             fprintf(stderr,
  432.                 "Warning: -G may be flaky.\n");    /* XXX */
  433.             break;
  434.  
  435.         case 'h':
  436.             f_follow_links++;    /* follow symbolic links */
  437.             break;
  438.  
  439.         case 'i':
  440.             f_ignorez++;        /* Ignore zero records (eofs) */
  441.             /*
  442.              * This can't be the default, because Unix tar
  443.              * writes two records of zeros, then pads out the
  444.              * block with garbage.
  445.              */
  446.             break;
  447.  
  448.         case 'k':            /* Don't overwrite files */
  449. #ifdef NO_OPEN3
  450.             fprintf(stderr,
  451.                 "%s: can't do -k option on this system\n",tar);
  452.             exit(EX_ARGSBAD);
  453. #else
  454.             f_keep++;
  455. #endif
  456.             break;
  457.  
  458.         case 'K':
  459.             f_startfile++;
  460.             addname(optarg);
  461.             break;
  462.  
  463.         case 'l':            /* When dumping directories, don't
  464.                            dump files/subdirectories that are
  465.                            on other filesystems. */
  466.             f_local_filesys++;
  467.             break;
  468.  
  469.         case 'L':
  470.             if (f_oldarch) {
  471.                 fprintf(stderr,
  472.                     "Can't use long names with V7 tar.\n");
  473.                 goto badopt;
  474.             }
  475. #ifdef ALLOW_LONG_NAMES
  476.             f_long_names++;
  477. #else
  478.             fprintf(stderr,
  479.                 "Warning: tar wasn't configured for long names.\n");
  480. #endif
  481.             break;
  482.  
  483.         case 'm':
  484.             f_modified++;
  485.             break;
  486.  
  487.         case 'M':            /* Make Multivolume archive:
  488.                            When we can't write any more
  489.                            into the archive, re-open it,
  490.                            and continue writing */
  491.             f_multivol++;
  492.             break;
  493.  
  494.         case 'n':            /* Don't recurse into
  495.                            sub directories */
  496.             f_no_recurse++;
  497.             break;
  498.  
  499.         case 'N':            /* Only write files newer than X */
  500.         get_newer:
  501.             f_new_files++;
  502.             new_time=getdate(optarg,(struct timeb *)0);
  503.             break;
  504.  
  505.         case 'o':            /* Generate old archive */
  506.             if(f_gnudump /* || f_dironly */)
  507.                 goto badopt;
  508.             if (f_long_names) {
  509.                 fprintf(stderr,
  510.                     "Can't use long names with V7 tar.\n");
  511.                 goto badopt;
  512.             }
  513.             f_oldarch++;
  514.             break;
  515.  
  516.         case 'O':
  517.             f_exstdout++;
  518.             break;
  519.  
  520.         case 'p':
  521.             f_use_protection++;
  522.             break;
  523.  
  524.         case 'P':
  525.             f_absolute_paths++;
  526.             break;
  527.  
  528.         case 'r':            /* Append files to the archive */
  529.             if(cmd_mode!=CMD_NONE)
  530.                 goto badopt;
  531.             cmd_mode=CMD_APPEND;
  532.             break;
  533.  
  534.         case 'R':
  535.             f_sayblock++;        /* Print block #s for debug */
  536.             break;            /* of bad tar archives */
  537.  
  538.         case 's':
  539.             f_sorted_names++;    /* Names to extr are sorted */
  540.             break;
  541.  
  542.         case 'S':            /* deal with sparse files */
  543.             f_sparse_files++;
  544.             fprintf(stderr,
  545.                 "Warning: support for sparse files is probably broken.");
  546.             fprintf(stderr, "Use at your own risk.");
  547.             break;
  548.         case 't':
  549.             if(cmd_mode!=CMD_NONE)
  550.                 goto badopt;
  551.             cmd_mode=CMD_LIST;
  552.             f_verbose++;        /* "t" output == "cv" or "xv" */
  553.             break;
  554.  
  555.         case 'T':
  556.             name_file = optarg;
  557.             f_namefile++;
  558.             break;
  559.  
  560.         case 'u':            /* Append files to the archive that
  561.                            aren't there, or are newer than the
  562.                            copy in the archive */
  563.             if(cmd_mode!=CMD_NONE)
  564.                 goto badopt;
  565.             cmd_mode=CMD_UPDATE;
  566.             break;
  567.  
  568.         case 'v':
  569.             f_verbose++;
  570.             break;
  571.  
  572.         case 'V':
  573.             f_volhdr=optarg;
  574.             break;
  575.  
  576.         case 'w':
  577.             f_confirm++;
  578.             break;
  579.  
  580.         case 'W':
  581.             f_verify++;
  582.             break;
  583.  
  584.         case 'x':            /* Extract files from the archive */
  585.             if(cmd_mode!=CMD_NONE)
  586.                 goto badopt;
  587.             cmd_mode=CMD_EXTRACT;
  588.             break;
  589.  
  590.         case 'X':
  591.             f_exclude++;
  592.             add_exclude(optarg);
  593.             break;
  594.  
  595.         case 'z':        /* Easy to type */
  596.         case 'Z':        /* Like the filename extension .Z */
  597.             f_compress++;
  598.             break;
  599.  
  600.         case '?':
  601.         default:
  602.         badopt:
  603.             fprintf(stderr, "%s: bad option.  Use '%s +help' for a complete list of options.\n", tar, tar);
  604.             exit(EX_ARGSBAD);
  605.         }
  606.     }
  607.  
  608.     blocksize = blocking * RECORDSIZE;
  609. }
  610.  
  611.  
  612. /*
  613.  * Print as much help as the user's gonna get.
  614.  *
  615.  * We have to sprinkle in the KLUDGE lines because too many compilers
  616.  * cannot handle character strings longer than about 512 bytes.  Yuk!
  617.  * In particular, MSDOS and Xenix MSC and PDP-11 V7 Unix have this
  618.  * problem.
  619.  */
  620. void
  621. describe()
  622. {
  623.     fprintf(stderr,"%s: choose one of the following:\n",tar);
  624.     fputs("\
  625. -A, +catenate        append tar files to an archive\n\
  626. -c, +create        create a new archive\n\
  627. -d, +compare        find differences between archive and file system\n\
  628. -D, +delete        delete from the archive (not for use on mag tapes!)\n\
  629. -r, +append        append files to the end of an archive\n\
  630. -t, +list        list the contents of an archive\n\
  631. -u, +update        only append files that are newer than copy in archive\n\
  632. -x, +extract        extract files from an archive\n",stderr);
  633.  
  634.     fputs("\
  635. Other options:\n\
  636. -b, +block-size N    block size of Nx512 bytes\n\
  637. -B, +read-full-blocks    reblock as we read (for reading 4.2BSD pipes)\n\
  638. -C, +directory dir    change to directory DIR\n\
  639. ", stderr); /* KLUDGE */ fputs("\
  640. -e, +debug              print extra debugging information\n\
  641. -f, +file F        use archive file or device F (or hostname:/dev/file)\n\
  642. -G, +incremental    create/list/extract GNU-format incremental backup\n\
  643. -h, +dereference    don't dump symlinks; dump the files they point to\n\
  644. -i, +ignore-zeros    ignore blocks of zeros in archive (normally mean EOF)\n\
  645. -k, +keep-old-files    keep existing files; don't overwrite them from archive\n\
  646. -K, +starting-file file    begin at FILE in the archive\n\
  647. -l, +one-file-system    stay in local file system when creating an archive\n\
  648. ", stderr); /* KLUDGE */ fputs("\
  649. -L            allow long file names when creating an archive\n\
  650. -m, +modification-time    don't extract file modified time\n\
  651. -M, +multi-volume    create/list/extract multi-volume archive\n\
  652. -n, +no_recurse         do not recurse into directories\n\
  653. -N, +after-date date    only store files newer than DATE\n\
  654. -o, +old-archive    write a  V7 format archive, rather than ANSI format\n\
  655. -O, +to-stdout        extract files to standard output\n\
  656. -p, +same-permissions    extract all protection information\n\
  657. -P, +absolute-paths    don't strip leading \"/\"es from file names\n\
  658. +preserve        like -p -s\n\
  659. -R, +record-number    show record number within archive with each message\n\
  660. -s, +same-order        list of names to extract is sorted to match archive\n\
  661. -S, +sparse-file    handle sparse files specially\n\
  662. ", stderr); /* KLUDGE */ fputs("\
  663. -T, +files-from F    get names to extract or create from file F\n\
  664. -v, +verbose        verbosely list files processed\n\
  665. -V, +volume vnam    create archive with volume name VNAM\n\
  666. +version        print tar program version number\n\
  667. -w, +interactive    ask for confirmation for every action\n\
  668. -W, +verify        attempt to verify the archive after writing it\n\
  669. -X, +exclude file    exclude files listed in FILE\n\
  670. -z,-Z,+compress        filter the archive through compress\n\
  671. -[0-7][lmh]        specify drive and density\n\
  672. ", stderr);
  673. }
  674.  
  675.  
  676. /*
  677.  * Set up to gather file names for tar.
  678.  *
  679.  * They can either come from stdin or from argv.
  680.  */
  681. name_init(argc, argv)
  682.     int    argc;
  683.     char    **argv;
  684. {
  685.  
  686.     if (f_namefile) {
  687.         if (optind < argc) {
  688.             fprintf(stderr, "tar: too many args with -T option\n");
  689.             exit(EX_ARGSBAD);
  690.         }
  691.         if (!strcmp(name_file, "-")) {
  692.             namef = stdin;
  693.         } else {
  694.             namef = fopen(name_file, "r");
  695.             if (namef == NULL) {
  696.                 msg_perror("can't open file %s",name_file);
  697.                 exit(EX_BADFILE);
  698.             }
  699.         }
  700.     } else {
  701.         /* Get file names from argv, after options. */
  702.         n_argc = argc;
  703.         n_argv = argv;
  704.     }
  705. }
  706.  
  707. /*
  708.  * Get the next name from argv or the name file.
  709.  *
  710.  * Result is in static storage and can't be relied upon across two calls.
  711.  */
  712.  
  713. /* C is non-zero if we should deal with -C */
  714. char *
  715. name_next(c)
  716. {
  717.     static char    buffer[MAXPATHLEN+2];    /* Holding pattern */
  718.     register char    *p;
  719.     register char    *q;
  720.     extern char *un_quote_string();
  721.  
  722.  tryagain:
  723.     if (namef == NULL) {
  724.         /* Names come from argv, after options */
  725.         if (optind < n_argc) {
  726.             /* JF trivial support for -C option.  I don't know if
  727.                chdir'ing at this point is dangerous or not.
  728.                It seems to work, which is all I ask. */
  729.             if(c && n_argv[optind][0]=='-' && n_argv[optind][1]=='C' && n_argv[optind][2]=='\0' && n_argv[optind+1]!=0) {
  730.                 optind++;
  731.                 if(chdir(n_argv[optind])<0) {
  732.                     msg_perror("Can't chdir to %s",n_argv[optind]);
  733.                 }
  734.                 optind++;
  735.                 if(optind>=n_argc)
  736.                     return (char *)NULL;
  737.             }
  738.             /* End of JF quick -C hack */
  739.  
  740.             if(f_exclude && check_exclude(n_argv[optind])) {
  741.                 optind++;
  742.                 goto tryagain;
  743.             }
  744.             return un_quote_string(n_argv[optind++]);
  745.         }
  746.         return (char *)NULL;
  747.     }
  748.     while(p = fgets(buffer, MAXPATHLEN+1 /*nl*/, namef)) {
  749.         q = p+strlen(p)-1;        /* Find the newline */
  750.         if (q <= p)            /* Ignore empty lines */
  751.             continue;
  752.         *q-- = '\0';            /* Zap the newline */
  753.         while (q > p && *q == '/')    /* Zap trailing /s */
  754.             *q-- = '\0';
  755.         if(f_exclude && check_exclude(p))
  756.             goto tryagain;
  757.         if (f_debug) {
  758.             fprintf(stderr, "name_next is %s\n", p);
  759.         }
  760.         return un_quote_string(p);
  761.     }
  762.     if (f_debug) {
  763.         fprintf(stderr, "name_next is NULL\n");
  764.     }
  765.     return NULL;
  766. }
  767.  
  768.  
  769. /*
  770.  * Close the name file, if any.
  771.  */
  772. name_close()
  773. {
  774.  
  775.     if (namef != NULL && namef != stdin) fclose(namef);
  776. }
  777.  
  778.  
  779. /*
  780.  * Gather names in a list for scanning.
  781.  * Could hash them later if we really care.
  782.  *
  783.  * If the names are already sorted to match the archive, we just
  784.  * read them one by one.  name_gather reads the first one, and it
  785.  * is called by name_match as appropriate to read the next ones.
  786.  * At EOF, the last name read is just left in the buffer.
  787.  * This option lets users of small machines extract an arbitrary
  788.  * number of files by doing "tar t" and editing down the list of files.
  789.  */
  790. name_gather()
  791. {
  792.     register char *p;
  793.     static struct name namebuf[1];    /* One-name buffer */
  794.     static char *chdir_name;
  795.  
  796.     if (f_sorted_names) {
  797.         p = name_next(0);
  798.         if (p) {
  799.             if(*p=='-' && p[1]=='C' && p[2]=='\0') {
  800.                 chdir_name=name_next(0);
  801.                 p=name_next(0);
  802.                 if(!p) {
  803.                     fprintf(stderr,"Missing file name after -C\n");
  804.                     exit(EX_ARGSBAD);
  805.                 }
  806.                 namebuf[0].change_dir=chdir_name;
  807.             }
  808.             namebuf[0].length = strlen(p);
  809.             if (namebuf[0].length >= sizeof namebuf[0].name) {
  810.                 fprintf(stderr, "Argument name too long: %s\n",
  811.                     p);
  812.                 namebuf[0].length = (sizeof namebuf[0].name) - 1;
  813.             }
  814.             strncpy(namebuf[0].name, p, namebuf[0].length);
  815.             namebuf[0].name[ namebuf[0].length ] = 0;
  816.             namebuf[0].next = (struct name *)NULL;
  817.             namebuf[0].found = 0;
  818.             namelist = namebuf;
  819.             namelast = namelist;
  820.         }
  821.         return;
  822.     }
  823.  
  824.     /* Non sorted names -- read them all in */
  825.     while (p = name_next(0))
  826.         addname(p);
  827. }
  828.  
  829. /*
  830.  * Add a name to the namelist.
  831.  */
  832. addname(name)
  833.     char    *name;            /* pointer to name */
  834. {
  835.     register int    i;        /* Length of string */
  836.     register struct name    *p;    /* Current struct pointer */
  837.     static char *chdir_name;
  838.     char *new_name();
  839. #define MAXPATHLEN 1024
  840.  
  841.     if(name[0]=='-' && name[1]=='C' && name[2]=='\0') {
  842.         chdir_name=name_next(0);
  843.         name=name_next(0);
  844.         if(!name) {
  845.             fprintf(stderr,"Missing file name after -C\n");
  846.             exit(EX_ARGSBAD);
  847.         }
  848.         if(chdir_name[0]!='/') {
  849.             char path[MAXPATHLEN];
  850. #if defined(MSDOS) || defined(USG)
  851.             int getcwd();
  852.  
  853.             if(!getcwd(path,MAXPATHLEN))
  854.                 fprintf(stderr,"Couldn't get current dir\n");
  855.                 exit(EX_SYSTEM);
  856. #else
  857.             char *getwd();
  858.  
  859.             if(!getwd(path)) {
  860.                 fprintf(stderr,"Couldn't get current dir: %s\n",path);
  861.                 exit(EX_SYSTEM);
  862.             }
  863. #endif
  864.             chdir_name=new_name(path,chdir_name);
  865.         }
  866.     }
  867.  
  868.     i = strlen(name);
  869.     /*NOSTRICT*/
  870.     p = (struct name *)
  871.         malloc((unsigned)(i + sizeof(struct name) - NAMSIZ));
  872.     if (!p) {
  873.         fprintf(stderr,"tar: cannot allocate mem for name %s\n",name);
  874.         exit(EX_SYSTEM);
  875.     }
  876.     p->next = (struct name *)NULL;
  877.     p->length = i;
  878.     strncpy(p->name, name, i);
  879.     p->name[i] = '\0';    /* Null term */
  880.     p->found = 0;
  881.     p->regexp = 0;        /* Assume not a regular expression */
  882.     p->firstch = 1;        /* Assume first char is literal */
  883.     p->change_dir=chdir_name;
  884.     p->dir_contents = 0;    /* JF */
  885.     if (index(name, '*') || index(name, '[') || index(name, '?')) {
  886.         p->regexp = 1;    /* No, it's a regexp */
  887.         if (name[0] == '*' || name[0] == '[' || name[0] == '?')
  888.             p->firstch = 0;        /* Not even 1st char literal */
  889.     }
  890.  
  891.     if (namelast) namelast->next = p;
  892.     namelast = p;
  893.     if (!namelist) namelist = p;
  894. }
  895.  
  896. add_dir_to_name(name,dirc)
  897. char *name;
  898. char *dirc;
  899. {
  900.     struct name *n;
  901.  
  902.     for(n=namelist;n;n=n->next) {
  903.         if(!strcmp(n->name,name)) {
  904.             n->dir_contents = dirc;
  905.             return;
  906.         }
  907.     }
  908. }
  909.  
  910. /*
  911.  * Match a name from an archive, p, with a name from the namelist.
  912.  */
  913. name_match(p)
  914.     register char *p;
  915. {
  916.     register struct name    *nlp;
  917.     register int        len;
  918.  
  919. again:
  920.     if (0 == (nlp = namelist))    /* Empty namelist is easy */
  921.         return 1;
  922.     len = strlen(p);
  923.     for (; nlp != 0; nlp = nlp->next) {
  924.         /* If first chars don't match, quick skip */
  925.         if (nlp->firstch && nlp->name[0] != p[0])
  926.             continue;
  927.  
  928.         /* Regular expressions */
  929.         if (nlp->regexp) {
  930.             if (wildmat(p, nlp->name)) {
  931.                 nlp->found = 1;    /* Remember it matched */
  932.                 if(f_startfile) {
  933.                     free((void *)namelist);
  934.                     namelist=0;
  935.                 }
  936.                 if(nlp->change_dir && chdir(nlp->change_dir))
  937.                     msg_perror("Can't change to directory %s\n",nlp->change_dir);
  938.                 return 1;    /* We got a match */
  939.             }
  940.             continue;
  941.         }
  942.  
  943.         /* Plain Old Strings */
  944.         if (nlp->length <= len        /* Archive len >= specified */
  945.          && (p[nlp->length] == '\0' || p[nlp->length] == '/')
  946.                         /* Full match on file/dirname */
  947.          && strncmp(p, nlp->name, nlp->length) == 0) /* Name compare */
  948.         {
  949.             nlp->found = 1;        /* Remember it matched */
  950.             if(f_startfile) {
  951.                 free((void *)namelist);
  952.                 namelist = 0;
  953.             }
  954.             if(nlp->change_dir && chdir(nlp->change_dir))
  955.                 msg_perror("Can't change to directory %s\n",nlp->change_dir);
  956.             return 1;        /* We got a match */
  957.         }
  958.     }
  959.  
  960.     /*
  961.      * Filename from archive not found in namelist.
  962.      * If we have the whole namelist here, just return 0.
  963.      * Otherwise, read the next name in and compare it.
  964.      * If this was the last name, namelist->found will remain on.
  965.      * If not, we loop to compare the newly read name.
  966.      */
  967.     if (f_sorted_names && namelist->found) {
  968.         name_gather();        /* Read one more */
  969.         if (!namelist->found) goto again;
  970.     }
  971.     return 0;
  972. }
  973.  
  974.  
  975. /*
  976.  * Print the names of things in the namelist that were not matched.
  977.  */
  978. names_notfound()
  979. {
  980.     register struct name    *nlp;
  981.     register char        *p;
  982.  
  983.     for (nlp = namelist; nlp != 0; nlp = nlp->next) {
  984.         if (!nlp->found) {
  985.             fprintf(stderr, "tar: %s not found in archive\n",
  986.                 nlp->name);
  987.         }
  988.         /*
  989.          * We could free() the list, but the process is about
  990.          * to die anyway, so save some CPU time.  Amigas and
  991.          * other similarly broken software will need to waste
  992.          * the time, though.
  993.          */
  994. #ifndef unix
  995.         if (!f_sorted_names)
  996.             free(nlp);
  997. #endif
  998.     }
  999.     namelist = (struct name *)NULL;
  1000.     namelast = (struct name *)NULL;
  1001.  
  1002.     if (f_sorted_names) {
  1003.         while (0 != (p = name_next(1)))
  1004.             fprintf(stderr, "tar: %s not found in archive\n", p);
  1005.     }
  1006. }
  1007.  
  1008. /* These next routines were created by JF */
  1009.  
  1010. name_expand()
  1011. {
  1012. ;
  1013. }
  1014. /* p is a directory.  Add all the files in P to the namelist.  If any of the
  1015.    files is a directory, recurse on the subdirectory. . . */
  1016. static
  1017. add_dir_name(p,device)
  1018. char *p;
  1019. int device;
  1020. {
  1021.     char *new_buf;
  1022.     char *p_buf;
  1023.     char *get_dir_contents();
  1024.     new_buf=get_dir_contents(p,device);
  1025.  
  1026.     add_dir_to_name(p,new_buf);
  1027.     {
  1028.         char namebuf[NAMSIZ+2];
  1029.         register int len;
  1030.  
  1031.         (void)strcpy(namebuf,p);
  1032.         len=strlen(namebuf);
  1033.         if(namebuf[len-1]!='/') {
  1034.             namebuf[len++]='/';
  1035.             namebuf[len]='\0';
  1036.         }
  1037.         for(p_buf=new_buf;*p_buf;p_buf+=strlen(p_buf)+1) {
  1038.             if(*p_buf=='D') {
  1039.                 (void)strcpy(namebuf+len,p_buf+1);
  1040.                 addname(namebuf);
  1041.                 add_dir_name(namebuf,device);
  1042.             }
  1043.         }
  1044.     }
  1045. }
  1046.  
  1047. char *
  1048. get_dir_contents(p,device)
  1049. char *p;
  1050. int device;
  1051. {
  1052.     register DIR *dirp;
  1053.     register struct direct *d;
  1054.     char namebuf[NAMSIZ+2];
  1055.     register int len;
  1056.     extern int errno;
  1057.  
  1058. #ifdef    __GNU__
  1059.     void *the_buffer;
  1060. #else
  1061.     char *the_buffer;
  1062. #endif
  1063.         char *buf,*p_buf;
  1064.         char **vec,**p_vec;
  1065.         int n_strs,n_size;
  1066.         char *new_buf;
  1067.         int dirent_cmp();
  1068.  
  1069.     if(f_local_filesys && device<0) {
  1070.         struct stat hs;
  1071.  
  1072.         if (0 != f_follow_links ? stat(p, &hs) : lstat(p, &hs))
  1073.             msg_perror("can't stat %s",namebuf);
  1074.         else
  1075.             device=hs.st_dev;
  1076.     }
  1077.     errno=0;
  1078.     dirp=opendir(p);
  1079.     if(!dirp) {
  1080.         if(errno)
  1081.             msg_perror("can't open directory %s",p);
  1082.         else
  1083.             msg("error opening directory %s",p);
  1084.         return "\0\0\0\0";
  1085.     }
  1086.     (void) strcpy(namebuf,p);
  1087.     if(p[strlen(p)-1]!='/')
  1088.         (void) strcat(namebuf,"/");
  1089.     len=strlen(namebuf);
  1090.  
  1091.     the_buffer=init_buffer();
  1092.     while(d=readdir(dirp)) {
  1093.         struct stat hs;
  1094.  
  1095.         /* Skip . and .. */
  1096.         if(is_dot_or_dotdot(d->d_name))
  1097.             continue;
  1098.         if(DP_NAMELEN(d) + len >=NAMSIZ) {
  1099.             msg("%s%s name too long: skipped",namebuf,d->d_name);
  1100.             continue;
  1101.         }
  1102.         (void) strcpy(namebuf+len,d->d_name);
  1103.         if (0 != f_follow_links? stat(namebuf, &hs): lstat(namebuf, &hs)) {
  1104.             msg_perror("can't stat %s",namebuf);
  1105.             continue;
  1106.         }
  1107.         if((f_new_files && new_time>hs.st_mtime && (hs.st_mode&S_IFMT)!=S_IFDIR
  1108.             && (f_new_files>1 || new_time>hs.st_ctime) )
  1109.            || (f_local_filesys && device>=0 && device!=hs.st_dev)
  1110.            || (f_exclude && check_exclude(namebuf)))
  1111.             add_buffer(the_buffer,"N",1);
  1112.         else if((hs.st_mode&S_IFMT)==S_IFDIR)
  1113.             add_buffer(the_buffer,"D",1);
  1114.         else
  1115.             add_buffer(the_buffer,"Y",1);
  1116.         add_buffer(the_buffer,d->d_name,(int)(DP_NAMELEN(d)+1));
  1117.     }
  1118.     add_buffer(the_buffer,"\000\000",2);
  1119.     closedir(dirp);
  1120.  
  1121.     /* Well, we've read in the contents of the dir, now sort them */
  1122.     buf=get_buffer(the_buffer);
  1123.     n_strs=0;
  1124.     n_size=0;
  1125.     for(p_buf=buf;*p_buf;) {
  1126.         int tmp;
  1127.  
  1128.         tmp=strlen(p_buf)+1;
  1129.         n_strs++;
  1130.         n_size+=tmp;
  1131.         p_buf+=tmp;
  1132.     }
  1133.     if(n_strs==0) {
  1134.         flush_buffer(the_buffer);
  1135.         return "\0\0\0\0";
  1136.     }
  1137.     vec=(char **)malloc(sizeof(char *)*(n_strs+1));
  1138.     for(p_vec=vec,p_buf=buf;*p_buf;p_buf+=strlen(p_buf)+1)
  1139.         *p_vec++= p_buf;
  1140.     *p_vec= 0;
  1141.     qsort((void *)vec,n_strs,sizeof(char *),dirent_cmp);
  1142.     new_buf=(char *)malloc(n_size+2);
  1143.     for(p_vec=vec,p_buf=new_buf;*p_vec;p_vec++) {
  1144.         char *p_tmp;
  1145.  
  1146.         for(p_tmp= *p_vec;*p_buf++= *p_tmp++;)
  1147.             ;
  1148.     }
  1149.     *p_buf++='\0';
  1150.     free(vec);
  1151.     flush_buffer(the_buffer);
  1152.     return new_buf;
  1153. }
  1154.  
  1155. int dirent_cmp(p1,p2)
  1156. char **p1,**p2;
  1157. {
  1158.     char *frst,*scnd;
  1159.  
  1160.     frst= (*p1)+1;
  1161.     scnd= (*p2)+1;
  1162.  
  1163.     return strcmp(frst,scnd);
  1164. }
  1165.  
  1166. /* This is like name_match(), except that it returns a pointer to the name
  1167.    it matched, and doesn't set ->found  The caller will have to do that
  1168.    if it wants to.  Oh, and if the namelist is empty, it returns 0, unlike
  1169.    name_match(), which returns TRUE */
  1170.  
  1171. struct name *
  1172. name_scan(p)
  1173. register char *p;
  1174. {
  1175.     register struct name    *nlp;
  1176.     register int        len;
  1177.  
  1178. again:
  1179.     if (0 == (nlp = namelist))    /* Empty namelist is easy */
  1180.         return 0;
  1181.     len = strlen(p);
  1182.     for (; nlp != 0; nlp = nlp->next) {
  1183.         /* If first chars don't match, quick skip */
  1184.         if (nlp->firstch && nlp->name[0] != p[0])
  1185.             continue;
  1186.  
  1187.         /* Regular expressions */
  1188.         if (nlp->regexp) {
  1189.             if (wildmat(p, nlp->name))
  1190.                 return nlp;    /* We got a match */
  1191.             continue;
  1192.         }
  1193.  
  1194.         /* Plain Old Strings */
  1195.         if (nlp->length <= len        /* Archive len >= specified */
  1196.          && (p[nlp->length] == '\0' || p[nlp->length] == '/')
  1197.                         /* Full match on file/dirname */
  1198.          && strncmp(p, nlp->name, nlp->length) == 0) /* Name compare */
  1199.             return nlp;        /* We got a match */
  1200.     }
  1201.  
  1202.     /*
  1203.      * Filename from archive not found in namelist.
  1204.      * If we have the whole namelist here, just return 0.
  1205.      * Otherwise, read the next name in and compare it.
  1206.      * If this was the last name, namelist->found will remain on.
  1207.      * If not, we loop to compare the newly read name.
  1208.      */
  1209.     if (f_sorted_names && namelist->found) {
  1210.         name_gather();        /* Read one more */
  1211.         if (!namelist->found) goto again;
  1212.     }
  1213.     return (struct name *) 0;
  1214. }
  1215.  
  1216. /* This returns a name from the namelist which doesn't have ->found set.
  1217.    It sets ->found before returning, so successive calls will find and return
  1218.    all the non-found names in the namelist */
  1219.  
  1220. struct name *gnu_list_name;
  1221.  
  1222. char *
  1223. name_from_list()
  1224. {
  1225.     if(!gnu_list_name)
  1226.         gnu_list_name = namelist;
  1227.     while(gnu_list_name && gnu_list_name->found)
  1228.         gnu_list_name=gnu_list_name->next;
  1229.     if(gnu_list_name) {
  1230.         gnu_list_name->found++;
  1231.         if(gnu_list_name->change_dir)
  1232.             if(chdir(gnu_list_name->change_dir)<0)
  1233.                 msg_perror("can't chdir to %s",gnu_list_name->change_dir);
  1234.         return gnu_list_name->name;
  1235.     }
  1236.     return (char *)0;
  1237. }
  1238.  
  1239. blank_name_list()
  1240. {
  1241.     struct name *n;
  1242.  
  1243.     gnu_list_name = 0;
  1244.     for(n=namelist;n;n=n->next)
  1245.         n->found = 0;
  1246. }
  1247.  
  1248. /* Collect all the names from argv[] (or whatever), then expand them into
  1249.    a directory tree, and put all the directories at the beginning. */
  1250. collect_and_sort_names()
  1251. {
  1252.     struct name *n,*n_next;
  1253.     int num_names;
  1254.     int name_cmp();
  1255.     char *merge_sort();
  1256.  
  1257.     name_gather();
  1258.  
  1259.     if(!namelist) addname(".");
  1260.     for(n=namelist;n;n=n_next) {
  1261.         n_next=n->next;
  1262.         if(n->found || n->dir_contents)
  1263.             continue;
  1264.         if(n->regexp)        /* FIXME just skip regexps for now */
  1265.             continue;
  1266.         if(n->change_dir)
  1267.             if(chdir(n->change_dir)<0) {
  1268.                 msg_perror("can't chdir to %s",n->change_dir);
  1269.                 continue;
  1270.             }
  1271.  
  1272.         if(is_a_directory(n->name)) {
  1273.             n->found++;
  1274.             add_dir_name(n->name,-1);
  1275.         }
  1276.     }
  1277.  
  1278.     num_names=0;
  1279.     for(n=namelist;n;n=n->next)
  1280.         num_names++;
  1281.     namelist=(struct name *)merge_sort((void *)namelist,num_names,(char *)(&(namelist->next))-(char *)namelist,name_cmp);
  1282.  
  1283.     for(n=namelist;n;n=n->next) {
  1284.         n->found=0;
  1285.     }
  1286. }
  1287.  
  1288. int name_cmp(n1,n2)
  1289. struct name *n1,*n2;
  1290. {
  1291.     if(n1->found) {
  1292.         if(n2->found)
  1293.             return strcmp(n1->name,n2->name);
  1294.         else
  1295.             return -1;
  1296.     } else if(n2->found)
  1297.         return 1;
  1298.     else
  1299.         return strcmp(n1->name,n2->name);
  1300. }
  1301.  
  1302. char *new_name();
  1303.  
  1304. gnu_restore(name)
  1305. char *name;
  1306. {
  1307.     char *current_dir;
  1308. /*    int current_dir_length; */
  1309.  
  1310.     char *archive_dir;
  1311. /*    int archive_dir_length; */
  1312. #ifdef __GNU__
  1313.     void *the_buffer;
  1314. #else
  1315.     char *the_buffer;
  1316. #endif
  1317.     char    *p;
  1318.     DIR    *dirp;
  1319.     struct direct *d;
  1320.     char *cur,*arc;
  1321.     extern struct stat hstat;        /* Stat struct corresponding */
  1322.     long size,copied;
  1323.     char *from,*to;
  1324.  
  1325.     dirp=opendir(name);
  1326.  
  1327.     if(!dirp) {
  1328.             /* The directory doesn't exist now.  It'll be created.
  1329.                In any case, we don't have to delete any files out
  1330.                of it */
  1331.         return;
  1332.     }
  1333.  
  1334.     the_buffer=init_buffer();
  1335.     while(d=readdir(dirp)) {
  1336.         if(is_dot_or_dotdot(d->d_name))
  1337.             continue;
  1338.  
  1339.         add_buffer(the_buffer,d->d_name,(int)(DP_NAMELEN(d)+1));
  1340.     }
  1341.     closedir(dirp);
  1342.     add_buffer(the_buffer,"",1);
  1343.  
  1344.     current_dir=get_buffer(the_buffer);
  1345.     archive_dir=(char *)malloc(hstat.st_size);
  1346.     if(archive_dir==0) {
  1347.         fprintf(stderr,"Can't allocate %d bytes for restore\n",hstat.st_size);
  1348.         return;
  1349.     }
  1350.     to=archive_dir;
  1351.     for(size=hstat.st_size;size>0;size-=copied) {
  1352.         from=findrec()->charptr;
  1353.         if(!from) {
  1354.             msg("Unexpected EOF in archive\n");
  1355.             break;
  1356.         }
  1357.         copied=endofrecs()->charptr - from;
  1358.         if(copied>size)
  1359.             copied=size;
  1360.         bcopy((void *)from,(void *)to,(int)copied);
  1361.         to+=copied;
  1362.         userec((union record *)(from+copied-1));
  1363.     }
  1364.  
  1365.     for(cur=current_dir;*cur;cur+=strlen(cur)+1) {
  1366.         for(arc=archive_dir;*arc;arc+=strlen(arc)+1) {
  1367.             arc++;
  1368.             if(!strcmp(arc,cur))
  1369.                 break;
  1370.         }
  1371.         if(*arc=='\0') {
  1372.             p=new_name(name,cur);
  1373.             if(f_confirm && !confirm("delete",p)) {
  1374.                 free(p);
  1375.                 continue;
  1376.             }
  1377.             if(f_verbose)
  1378.                 printf("%s: deleting %s\n",p);
  1379.             if(recursively_delete(p)) {
  1380.                 msg("%s: Error while deleting\n",p);
  1381.             }
  1382.             free(p);
  1383.         }
  1384.  
  1385.     }
  1386.     flush_buffer(the_buffer);
  1387.     free(archive_dir);
  1388. }
  1389.  
  1390. recursively_delete(path)
  1391. char *path;
  1392. {
  1393.     struct stat sbuf;
  1394.     DIR *dirp;
  1395.     struct direct *dp;
  1396.     char *path_buf;
  1397.     /* int path_len; */
  1398.  
  1399.  
  1400.     if(lstat(path,&sbuf)<0)
  1401.         return 1;
  1402.     if((sbuf.st_mode &S_IFMT)==S_IFDIR) {
  1403.  
  1404.         /* path_len=strlen(path); */
  1405.         dirp=opendir(path);
  1406.         if(dirp==0)
  1407.             return 1;
  1408.         while(dp=readdir(dirp)) {
  1409.             if(is_dot_or_dotdot(dp->d_name))
  1410.                 continue;
  1411.             path_buf=new_name(path,dp->d_name);
  1412.             if(recursively_delete(path_buf)) {
  1413.                 free(path_buf);
  1414.                 closedir(dirp);
  1415.                 return 1;
  1416.             }
  1417.             free(path_buf);
  1418.         }
  1419.         closedir(dirp);
  1420.  
  1421.         if(rmdir(path)<0)
  1422.             return 1;
  1423.         return 0;
  1424.     }
  1425.     if(unlink(path)<0)
  1426.         return 1;
  1427.     return 0;
  1428. }
  1429.  
  1430. char *
  1431. new_name(path,name)
  1432. char *path,*name;
  1433. {
  1434.     char *path_buf;
  1435.  
  1436.     path_buf=(char *)malloc(strlen(path)+strlen(name)+2);
  1437.     if(path_buf==0) {
  1438.         fprintf(stderr,"Can't allocate memory for name '%s/%s\n",path,name);
  1439.         exit(EX_SYSTEM);
  1440.     }
  1441.     (void) sprintf(path_buf,"%s/%s",path,name);
  1442.     return path_buf;
  1443. }
  1444.  
  1445. /* return non-zero if p is the name of a directory */
  1446. is_a_directory(p)
  1447. char *p;
  1448. {
  1449.     struct stat stbuf;
  1450.  
  1451.     if(lstat(p,&stbuf)<0) {
  1452.         msg_perror("can't stat %s",p);
  1453.         return 0;
  1454.     }
  1455.     if((stbuf.st_mode&S_IFMT)==S_IFDIR)
  1456.         return 1;
  1457.     return 0;
  1458. }
  1459.  
  1460. /* Returns non-zero if p is . or ..   This could be a macro for speed. */
  1461. is_dot_or_dotdot(p)
  1462. char *p;
  1463. {
  1464.     return (p[0]=='.' && (p[1]=='\0' || (p[1]=='.' && p[2]=='\0')));
  1465. }
  1466.  
  1467. /* returns non-zero if the luser typed 'y' or 'Y', zero otherwise. */
  1468.  
  1469. int
  1470. confirm(action,file)
  1471. char *action, *file;
  1472. {
  1473.     int    c,nl;
  1474.     static FILE *confirm_file = 0;
  1475.     extern FILE *msg_file;
  1476.     extern char TTY_NAME[];
  1477.  
  1478.     fprintf(msg_file,"%s %s?", action, file);
  1479.     fflush(msg_file);
  1480.     if(!confirm_file) {
  1481.         confirm_file = (archive == 0) ? fopen(TTY_NAME, "r") : stdin;
  1482.         if(!confirm_file) {
  1483.             fprintf(stderr,"Can't read confirmation from user\n");
  1484.             exit(EX_SYSTEM);
  1485.         }
  1486.     }
  1487.     c=getc(confirm_file);
  1488.     for(nl = c; nl != '\n' && nl != EOF; nl = getc(confirm_file))
  1489.         ;
  1490.     return (c=='y' || c=='Y');
  1491. }
  1492.  
  1493. char *x_buffer = 0;
  1494. int size_x_buffer;
  1495. int free_x_buffer;
  1496.  
  1497. char **exclude = 0;
  1498. int size_exclude = 0;
  1499. int free_exclude = 0;
  1500.  
  1501. char **re_exclude = 0;
  1502. int size_re_exclude = 0;
  1503. int free_re_exclude = 0;
  1504.  
  1505. add_exclude(file)
  1506. char *file;
  1507. {
  1508.     FILE *fp;
  1509.     char buf[1024];
  1510.     extern char *rindex();
  1511.  
  1512.     if(strcmp(file, "-"))
  1513.         fp=fopen(file,"r");
  1514.     else
  1515.         /* Let's hope the person knows what they're doing. */
  1516.         /* Using -X - -T - -f - will get you *REALLY* strange
  1517.            results. . . */
  1518.         fp=stdin;
  1519.  
  1520.     if(!fp) {
  1521.         msg_perror("can't open %s",file);
  1522.         exit(2);
  1523.     }
  1524.     while(fgets(buf,1024,fp)) {
  1525.         int size_buf;
  1526.         char *end_str;
  1527.  
  1528.         end_str=rindex(buf,'\n');
  1529.         *end_str='\0';
  1530.  
  1531.         un_quote_string(buf);
  1532.         size_buf = strlen(buf);
  1533.  
  1534.         if(x_buffer==0) {
  1535.             x_buffer = (char *)ck_malloc(size_buf+1024);
  1536.             free_x_buffer=1024;
  1537.         } else if(free_x_buffer<=size_buf) {
  1538.             char *old_x_buffer;
  1539.             char **tmp_ptr;
  1540.  
  1541.             old_x_buffer = x_buffer;
  1542.             x_buffer = (char *)ck_realloc(x_buffer,size_x_buffer+1024);
  1543.             free_x_buffer = 1024;
  1544.             for(tmp_ptr=exclude;tmp_ptr<exclude+size_exclude;tmp_ptr++)
  1545.                 *tmp_ptr= x_buffer + ((*tmp_ptr) - old_x_buffer);
  1546.             for(tmp_ptr=re_exclude;tmp_ptr<re_exclude+size_re_exclude;tmp_ptr++)
  1547.                 *tmp_ptr= x_buffer + ((*tmp_ptr) - old_x_buffer);
  1548.         }
  1549.  
  1550.         if(is_regex(buf)) {
  1551.             if(free_re_exclude==0) {
  1552.                 re_exclude= (char **)(re_exclude ? ck_realloc(re_exclude,(size_re_exclude+32)*sizeof(char *)) : ck_malloc(sizeof(char *)*32));
  1553.                 free_re_exclude+=32;
  1554.             }
  1555.             re_exclude[size_re_exclude]=x_buffer+size_x_buffer;
  1556.             size_re_exclude++;
  1557.             free_re_exclude--;
  1558.         } else {
  1559.             if(free_exclude==0) {
  1560.                 exclude=(char **)(exclude ? ck_realloc(exclude,(size_exclude+32)*sizeof(char *)) : ck_malloc(sizeof(char *)*32));
  1561.                 free_exclude+=32;
  1562.             }
  1563.             exclude[size_exclude]=x_buffer+size_x_buffer;
  1564.             size_exclude++;
  1565.             free_exclude--;
  1566.         }
  1567.         strcpy(x_buffer+size_x_buffer,buf);
  1568.         size_x_buffer+=size_buf+1;
  1569.         free_x_buffer-=size_buf+1;
  1570.     }
  1571.     fclose(fp);
  1572. }
  1573.  
  1574. int
  1575. is_regex(str)
  1576. char *str;
  1577. {
  1578.     return index(str,'*') || index(str,'[') || index(str,'?');
  1579. }
  1580.  
  1581. /* Returns non-zero if the file 'name' should not be added/extracted */
  1582. int
  1583. check_exclude(name)
  1584. char *name;
  1585. {
  1586.     int n;
  1587.  
  1588.     for(n=0;n<size_re_exclude;n++) {
  1589.         if(wildmat(name,re_exclude[n]))
  1590.             return 1;
  1591.     }
  1592.     for(n=0;n<size_exclude;n++) {
  1593.         if(strstr(name,exclude[n]))
  1594.             return 1;
  1595.     }
  1596.     return 0;
  1597. }
  1598.  
  1599.  
  1600. /*
  1601.  *----------------------------------------------------------------------
  1602.  *
  1603.  * gnu_extended_header --
  1604.  *
  1605.  *    Decide whether the current header is followed by extended header 
  1606.  *    records.
  1607.  *
  1608.  * Results:
  1609.  *    Returns non-zero if the current header is followed by extended
  1610.  *    header records.  Returns zero if not.
  1611.  *
  1612.  * Side effects:
  1613.  *    Exits if the header claims to be extended but lacks the right magic 
  1614.  *    number.  (This is an attempt to detect Posix headers with long 
  1615.  *    names, which we don't know how to handle.)
  1616.  *
  1617.  *----------------------------------------------------------------------
  1618.  */
  1619.  
  1620. int
  1621. gnu_extended_header(myHdr)
  1622.     union record *myHdr;    /* the header to look at */
  1623. {
  1624.     if (!myHdr->header.isextended) {
  1625.         return 0;
  1626.     } else if (myHdr->header.hdr_magic == HDR_MAGIC) {
  1627.         return 1;
  1628.     } else {
  1629.         msg("header has wrong magic number--Posix header, maybe?");
  1630.         exit(1);
  1631.         return 0;    /* lint */
  1632.     }
  1633. }
  1634.  
  1635.  
  1636. /*
  1637.  *----------------------------------------------------------------------
  1638.  *
  1639.  * extended_header_type_name --
  1640.  *
  1641.  *    Get a printable name for the type of an extended header record.
  1642.  *
  1643.  * Results:
  1644.  *    Returns the type, as a printable string.
  1645.  *
  1646.  * Side effects:
  1647.  *    None.
  1648.  *
  1649.  *----------------------------------------------------------------------
  1650.  */
  1651.  
  1652. char *
  1653. extended_header_type_name(type)
  1654.     unsigned char type;
  1655. {
  1656.     switch (type) {
  1657.     case XH_FILENAME:
  1658.         return "file name";
  1659.         break;
  1660.     case XH_LINKNAME:
  1661.         return "link name";
  1662.         break;
  1663.     case XH_SPARSE_FILE:
  1664.         return "sparse file";
  1665.         break;
  1666.     default:
  1667.         panic("bogus extended header type: %d\n", type);
  1668.         break;
  1669.     }
  1670.  
  1671.     /* NOTREACHED */
  1672. }
  1673. @
  1674.  
  1675.  
  1676. 1.4
  1677. log
  1678. @Paranoia check (Mike checking in for Bob).
  1679. @
  1680. text
  1681. @d271 1
  1682. a271 1
  1683.                   "01234567Ab:BcC:dDef:F:GhikK:lmMnN:oOpPrRsStT:uvV:wWxX:zZ",
  1684. d311 1
  1685. a311 1
  1686.                 d=getoldopt(argc,argv,"lmh");
  1687. d358 5
  1688. d387 2
  1689. d425 14
  1690. d464 5
  1691. d500 3
  1692. d605 1
  1693. d1553 75
  1694. @
  1695.  
  1696.  
  1697. 1.3
  1698. log
  1699. @Added debug flag.
  1700. @
  1701. text
  1702. @d31 1
  1703. d208 2
  1704. @
  1705.  
  1706.  
  1707. 1.2
  1708. log
  1709. @Added support for long filenames and long symbolic linkes.
  1710. @
  1711. text
  1712. @d195 2
  1713. a196 1
  1714. #endif    
  1715. d240 3
  1716. d268 1
  1717. a268 1
  1718.                   "01234567Ab:BcC:dDf:F:GhikK:lmMnN:oOpPrRsStT:uvV:wWxX:zZ",
  1719. d270 2
  1720. a271 2
  1721.           if (c == 0 && long_options[ind].flag == 0)
  1722.                 c = long_options[ind].val;
  1723. d357 5
  1724. a361 1
  1725.         case 'f':            /* Use ar_file for the archive */
  1726. d525 1
  1727. a528 1
  1728.  
  1729. d564 1
  1730. d680 3
  1731. d684 3
  1732. @
  1733.  
  1734.  
  1735. 1.1
  1736. log
  1737. @Initial revision
  1738. @
  1739. text
  1740. @d33 1
  1741. d193 3
  1742. d236 1
  1743. a236 1
  1744.          fprintf (stderr,"For more information, type ``%s +help''.\n",tar);
  1745. d264 1
  1746. a264 1
  1747.                   "01234567Ab:BcC:dDf:F:GhikK:lmMN:oOpPrRsStT:uvV:wWxX:zZ",
  1748. d270 1
  1749. a270 1
  1750.               break;
  1751. d418 5
  1752. d566 1
  1753. d631 1
  1754. a631 1
  1755.     static char    buffer[NAMSIZ+2];    /* Holding pattern */
  1756. d662 1
  1757. a662 1
  1758.     while(p = fgets(buffer, NAMSIZ+1 /*nl*/, namef)) {
  1759. @
  1760.